import { ipcMain, BrowserWindow } from 'electron'
// @ts-ignore - screenshot-desktop没有类型定义
import screenshot from 'screenshot-desktop'
import { IPC_CHANNELS } from 'shared/ipcChannels'
import log from 'electron-log'
import sharp from 'sharp'
import windowManager from '../windowManager'
import path from 'node:path'
import fs from 'node:fs'
import { 
  getAliCloudVoiceService, 
  initAliCloudVoiceService, 
  initAliCloudVoiceServiceFromConfig,
  destroyAliCloudVoiceService, 
  AliCloudVoiceService,
  AliCloudVoiceConfigLegacy
} from '../services/AliCloudVoiceService'
import { aliCloudConfigManager } from '../utils/AliCloudConfigManager'
import { imageMatchService } from '../services/ImageMatchService'
import { 
  initUmiOCRService, 
  getUmiOCRService, 
  destroyUmiOCRService 
} from '../services/UmiOCRService'

// 监控状态
let monitorInterval: NodeJS.Timeout | null = null
let currentConfig: LiveWakeupConfig | null = null
let isProcessing = false
let isLoadingTemplates = false // 模板加载状态
let monitoringWindow: Electron.WebContents | null = null // 记录发起监控的窗口

/**
 * 异步加载模板图片（不阻塞启动流程）
 */
async function loadTemplatesAsync(templates: Array<{ id: string; name: string; path: string; threshold: number }>): Promise<void> {
  try {
    const startTime = Date.now()
    
    for (const template of templates) {
      // 检查是否已停止监控
      if (!currentConfig) {
        log.info('[模板加载] 监控已停止，取消加载')
        isLoadingTemplates = false
        return
      }
      
      try {
        await imageMatchService.loadTemplate(template)
        log.info(`[模板加载] ✅ 已加载 (${templates.indexOf(template) + 1}/${templates.length}): ${template.name}`)
      } catch (error) {
        log.error(`[模板加载] ❌ 加载失败: ${template.name}`, error)
        throw new Error(`加载模板"${template.name}"失败: ${error instanceof Error ? error.message : '未知错误'}`)
      }
    }
    
    const elapsed = Date.now() - startTime
    log.info(`[模板加载] 🎉 所有模板加载完成，耗时: ${elapsed}ms，开始正常检测`)
    isLoadingTemplates = false
  } catch (error) {
    isLoadingTemplates = false
    throw error
  }
}

/**
 * 图像预处理（提高OCR识别率）
 * 支持多种预处理模式：none, light, standard, strong
 */
async function preprocessImageForOCR(imgBuffer: Buffer, mode: 'none' | 'light' | 'standard' | 'strong' = 'light'): Promise<Buffer> {
  try {
    log.info(`[图像预处理] 开始预处理，模式: ${mode}`)
    
    // 如果关闭预处理，直接返回原始图像
    if (mode === 'none') {
      log.info('[图像预处理] 预处理已关闭，使用原始图像')
      return imgBuffer
    }
    
    let pipeline = sharp(imgBuffer).greyscale() // 所有模式都先灰度化
    
    // 根据不同模式应用不同的处理策略
    switch (mode) {
      case 'light': {
        // 轻度模式：温和增强，适合大多数场景
        log.info('[图像预处理] 使用轻度模式')
        const processedBuffer = await pipeline
          .normalise() // 自动对比度
          .linear(1.2, 3) // 轻度线性增强
          .png()
          .toBuffer()
        return processedBuffer
      }
      
      case 'standard': {
        // 标准模式：平衡的增强效果
        log.info('[图像预处理] 使用标准模式')
        const processedBuffer = await pipeline
          .normalise() // 自动对比度
          .linear(1.3, 5) // 适度线性增强
          .sharpen({ sigma: 0.5 }) // 轻度锐化
          .png()
          .toBuffer()
        return processedBuffer
      }
      
      case 'strong': {
        // 强力模式：强对比度增强，适合暗图或模糊文字
        log.info('[图像预处理] 使用强力模式')
        const processedBuffer = await pipeline
          .normalise() // 自动对比度
          .linear(1.5, 10) // 强线性增强
          .sharpen() // 标准锐化
          .gamma(1.3) // gamma增强
          .png()
          .toBuffer()
        return processedBuffer
      }
      
      default:
        log.warn(`[图像预处理] 未知模式: ${mode}，使用轻度模式`)
        const processedBuffer = await pipeline
          .normalise()
          .linear(1.2, 3)
          .png()
          .toBuffer()
        return processedBuffer
    }
  } catch (error) {
    log.error('[图像预处理] 预处理失败，使用原始图像:', error)
    return imgBuffer
  }
}

/**
 * 截图并进行检测（OCR或图像匹配）
 */
async function captureAndDetect(): Promise<void> {
  // 如果已停止监控或正在处理中，直接返回
  if (isProcessing || !currentConfig) {
    return
  }

  isProcessing = true

  try {
    // 1. 截取屏幕
    log.info('[直播叫醒] 开始截取屏幕...')
    let imgBuffer = await screenshot()
    
    // 再次检查是否已停止（避免截图过程中被停止）
    if (!currentConfig) {
      log.info('[直播叫醒] 监控已停止，取消本次识别')
      isProcessing = false
      return
    }
    
    // 2. 如果配置了区域，裁剪图片
    if (currentConfig.captureRegion) {
      const { x, y, width, height } = currentConfig.captureRegion
      log.info(`[直播叫醒] 裁剪区域: x=${x}, y=${y}, width=${width}, height=${height}`)
      
      try {
        imgBuffer = await sharp(imgBuffer)
          .extract({
            left: Math.round(x),
            top: Math.round(y),
            width: Math.round(width),
            height: Math.round(height),
          })
          .png()
          .toBuffer()
        
        log.info('[直播叫醒] 区域裁剪成功')
      } catch (cropError) {
        log.error('[直播叫醒] 裁剪失败，使用完整截图:', cropError)
      }
    }

    // 3. 根据检测模式执行不同的检测逻辑
    const detectionMode = currentConfig.detectionMode || 'ocr'
    
    if (detectionMode === 'image-match') {
      // 图像匹配模式：在主进程直接进行匹配
      
      // 如果模板还在加载中，跳过本次检测
      if (isLoadingTemplates) {
        log.info('[直播叫醒] ⏳ 模板图片加载中，跳过本次检测')
        isProcessing = false
        return
      }
      
      log.info('[直播叫醒] 使用图像匹配模式')
      
      const matchResults = await imageMatchService.findTemplates(imgBuffer)
      
      if (matchResults.length > 0 && matchResults.some(r => r.found)) {
        // 找到匹配，触发警报
        const matchedTemplate = matchResults.find(r => r.found)!
        log.info(`[直播叫醒] 🚨 图像匹配成功: ${matchedTemplate.templateName}, 置信度: ${(matchedTemplate.confidence * 100).toFixed(2)}%`)
        
        // 立即停止监控定时器，不再继续检测
        if (monitorInterval) {
          log.info('[直播叫醒] 图像匹配成功，停止监控定时器')
          clearInterval(monitorInterval)
          monitorInterval = null
        }
        
        // 转换为Base64（用于显示）
        const screenshotBase64 = currentConfig.saveScreenshot 
          ? `data:image/png;base64,${imgBuffer.toString('base64')}`
          : undefined
        
        // 通知渲染进程触发警报
        triggerAlert(matchedTemplate.templateName || '未知模板', screenshotBase64)
      }
    } else {
      // OCR模式
      log.info('[直播叫醒] 使用OCR模式')
      
      // 🎨 对图像进行预处理以提高OCR识别率（使用配置的模式）
      const originalBuffer = imgBuffer
      const preprocessMode = currentConfig.preprocessMode || 'light'
      const processedBuffer = await preprocessImageForOCR(imgBuffer, preprocessMode)
      
      // 转换为Base64（发送预处理后的图像用于OCR识别）
      const screenshotBase64 = `data:image/png;base64,${processedBuffer.toString('base64')}`
      // 原始图像（用于显示/保存）
      const originalBase64 = `data:image/png;base64,${originalBuffer.toString('base64')}`

      // 最后一次检查：确保在发送前监控仍在运行
      if (!currentConfig) {
        log.info('[直播叫醒] 截图完成但监控已停止，不发送OCR请求')
        isProcessing = false
        return
      }

      // 根据 OCR 引擎配置选择识别方式
      const ocrEngine = currentConfig.ocrEngine?.engine || 'tesseract'
      
      if (ocrEngine === 'umi-ocr') {
        // 使用 Umi-OCR 在主进程进行识别
        log.info('[直播叫醒] 使用 Umi-OCR 引擎')
        
        const umiService = getUmiOCRService()
        if (!umiService) {
          log.error('[直播叫醒] Umi-OCR 服务未初始化')
          isProcessing = false
          return
        }
        
        // 执行 OCR 识别
        const ocrResult = await umiService.recognize(screenshotBase64)
        
        if (ocrResult.success && ocrResult.text) {
          log.info(`[直播叫醒] Umi-OCR 识别结果: ${ocrResult.text}`)
          
          // 检查是否包含关键词
          const foundKeyword = currentConfig.keywords.find(keyword => 
            ocrResult.text!.includes(keyword)
          )
          
          if (foundKeyword) {
            log.info(`[直播叫醒] 🚨 检测到关键词: ${foundKeyword}`)
            
            // 立即停止监控定时器，不再继续检测
            if (monitorInterval) {
              log.info('[直播叫醒] 检测到关键词，停止监控定时器')
              clearInterval(monitorInterval)
              monitorInterval = null
            }
            
            // 触发警报
            const screenshot = currentConfig.saveScreenshot ? originalBase64 : undefined
            triggerAlert(foundKeyword, screenshot)
          }
        } else {
          log.warn('[直播叫醒] Umi-OCR 识别失败:', ocrResult.error)
        }
      } else {
        // 使用 Tesseract：发送到渲染进程进行OCR识别
        log.info('[直播叫醒] 使用 Tesseract 引擎')
        
        const ocrData = {
          screenshot: screenshotBase64, // 预处理后的图像用于OCR
          originalScreenshot: originalBase64, // 原始图像用于显示
          keywords: currentConfig.keywords,
          saveScreenshot: currentConfig.saveScreenshot,
        }
        
        // 优先发送给悬浮窗
        const floatingWindow = windowManager.getLiveWakeupFloatingWindow()
        if (floatingWindow && !floatingWindow.isDestroyed()) {
          floatingWindow.webContents.send(IPC_CHANNELS.liveWakeup.performOCR, ocrData)
        } else {
          // 如果没有悬浮窗，发送给主窗口
          const mainWindow = windowManager.getMainWindow()
          if (mainWindow && !mainWindow.isDestroyed()) {
            mainWindow.webContents.send(IPC_CHANNELS.liveWakeup.performOCR, ocrData)
          }
        }
      }
    }

    isProcessing = false
  } catch (error) {
    log.error('[直播叫醒] 截图/检测失败:', error)
    isProcessing = false
  }
}

/**
 * 触发警报（从主进程）
 * 根据叫醒模式配置决定使用电话叫醒还是音频警报
 */
async function triggerAlert(keyword: string, screenshot?: string) {
  const alertData = {
    keyword,
    screenshot,
    timestamp: Date.now(),
  }

  // 检查叫醒模式配置
  if (currentConfig?.wakeupMode?.type === 'phone' && currentConfig.wakeupMode.phoneNumber) {
    // 电话叫醒模式
    log.info('[叫醒] 使用电话叫醒模式（图像匹配触发）')
    try {
      const service = getAliCloudVoiceService()
      if (!service) {
        log.error('[叫醒] 阿里云语音服务未初始化，回退到音频警报')
        // 回退到音频警报
        if (monitoringWindow && !monitoringWindow.isDestroyed()) {
          monitoringWindow.send(IPC_CHANNELS.liveWakeup.alertTriggered, alertData)
        }
        return
      }

      const ttsCode = `检测到关键词"${keyword}"，请立即查看直播状态！`
      const callParams: VoiceCallParams = {
        phoneNumber: currentConfig.wakeupMode.phoneNumber,
        ttsCode: ttsCode,
        playTimes: 3 // 叫醒电话播放3次
      }

      const result = await service.sendVoiceCaptcha(callParams)
      
      if (result.success) {
        log.info(`[叫醒] 电话叫醒成功，通话ID: ${result.callId}`)
        // 也发送警报事件到前端显示提示（但不播放音频）
        if (monitoringWindow && !monitoringWindow.isDestroyed()) {
          monitoringWindow.send(IPC_CHANNELS.liveWakeup.alertTriggered, { ...alertData, phoneCallSent: true })
        }
      } else {
        log.error(`[叫醒] 电话叫醒失败: ${result.error}，回退到音频警报`)
        // 电话叫醒失败时，回退到音频警报
        if (monitoringWindow && !monitoringWindow.isDestroyed()) {
          monitoringWindow.send(IPC_CHANNELS.liveWakeup.alertTriggered, alertData)
        }
      }
    } catch (error) {
      log.error('[叫醒] 电话叫醒异常:', error)
      // 异常时回退到音频警报
      if (monitoringWindow && !monitoringWindow.isDestroyed()) {
        monitoringWindow.send(IPC_CHANNELS.liveWakeup.alertTriggered, alertData)
      }
    }
  } else {
    // 音频叫醒模式或电话模式配置不完整时
    log.info('[叫醒] 使用音频警报模式')
    // 发送警报事件到发起监控的窗口
    if (monitoringWindow && !monitoringWindow.isDestroyed()) {
      monitoringWindow.send(IPC_CHANNELS.liveWakeup.alertTriggered, alertData)
    }
  }
}

/**
 * 启动监控
 */
async function startMonitoring(config: LiveWakeupConfig, webContents: Electron.WebContents) {
  try {
    log.info('[直播叫醒] 启动监控, 配置:', JSON.stringify(config))
    
    // 先彻底停止现有监控
    if (monitorInterval) {
      log.info('[直播叫醒] 检测到现有监控，先停止...')
      clearInterval(monitorInterval)
      monitorInterval = null
    }
    
    // 清空之前的模板
    imageMatchService.clearTemplates()
    
    // 重置状态
    isProcessing = false
    currentConfig = config
    monitoringWindow = webContents // 记录发起监控的窗口

    // 如果使用 Umi-OCR，初始化服务
    if (config.ocrEngine?.engine === 'umi-ocr' && config.ocrEngine.umiOcr) {
      log.info('[直播叫醒] 初始化 Umi-OCR 服务')
      try {
        const umiService = initUmiOCRService({
          apiUrl: config.ocrEngine.umiOcr.apiUrl,
          language: config.ocrEngine.umiOcr.language || 'chi_sim',
          timeout: config.ocrEngine.umiOcr.timeout || 10000,
        })
        
        // 测试连接
        const testResult = await umiService.testConnection()
        if (!testResult.success) {
          log.error('[直播叫醒] Umi-OCR 服务连接失败:', testResult.error)
          return {
            success: false,
            error: `Umi-OCR 服务连接失败: ${testResult.error}`,
          }
        }
        
        log.info('[直播叫醒] Umi-OCR 服务初始化成功')
      } catch (error) {
        log.error('[直播叫醒] Umi-OCR 服务初始化异常:', error)
        return {
          success: false,
          error: `Umi-OCR 服务初始化失败: ${error instanceof Error ? error.message : '未知错误'}`,
        }
      }
    }

    // 如果是图像匹配模式，异步加载模板图片（不阻塞启动）
    if (config.detectionMode === 'image-match' && config.templateImages && config.templateImages.length > 0) {
      log.info(`[直播叫醒] 图像匹配模式，将在后台加载 ${config.templateImages.length} 个模板`)
      
      isLoadingTemplates = true
      
      // 🚀 使用 setImmediate 确保完全异步，不阻塞任何操作
      setImmediate(() => {
        loadTemplatesAsync(config.templateImages!).catch(error => {
          log.error('[直播叫醒] 后台加载模板失败:', error)
          isLoadingTemplates = false
          
          // 停止监控
          if (monitorInterval) {
            clearInterval(monitorInterval)
            monitorInterval = null
          }
          currentConfig = null
          
          // 通知前端加载失败
          const mainWindow = windowManager.getMainWindow()
          if (mainWindow && !mainWindow.isDestroyed()) {
            mainWindow.webContents.send(IPC_CHANNELS.liveWakeup.stoppedEvent)
          }
          const floatingWindow = windowManager.getLiveWakeupFloatingWindow()
          if (floatingWindow && !floatingWindow.isDestroyed()) {
            floatingWindow.webContents.send(IPC_CHANNELS.liveWakeup.stoppedEvent)
          }
        })
      })
    }

    // 定时执行检测
    const intervalMs = config.checkInterval * 1000
    
    log.info(`[直播叫醒] 准备启动监控，检测间隔: ${config.checkInterval}秒，检测模式: ${config.detectionMode || 'ocr'}`)
    
    // 立即执行一次检测
    captureAndDetect()
    
    // 然后按间隔定时检测
    monitorInterval = setInterval(() => {
      log.info('[直播叫醒] 定时器触发')
      captureAndDetect()
    }, intervalMs)

    log.info(`[直播叫醒] 监控已启动，定时器ID: ${monitorInterval}`)
    
    return {
      success: true,
    }
  } catch (error) {
    log.error('[直播叫醒] 启动监控失败:', error)
    return {
      success: false,
      error: error instanceof Error ? error.message : '未知错误',
    }
  }
}

/**
 * 停止监控
 */
function stopMonitoring() {
  log.info('[直播叫醒] 🛑 开始停止监控...')
  
  // 立即清空配置，阻止新的截图任务和OCR请求
  currentConfig = null
  isLoadingTemplates = false // 重置加载状态
  log.info('[直播叫醒] ✓ 配置已清空')
  
  // 清除定时器，防止新的检测任务
  if (monitorInterval) {
    log.info(`[直播叫醒] ✓ 清除定时器: ${monitorInterval}`)
    clearInterval(monitorInterval)
    monitorInterval = null
  } else {
    log.info('[直播叫醒] - 没有活动的定时器')
  }
  
  // 清空图像匹配模板
  imageMatchService.clearTemplates()
  log.info('[直播叫醒] ✓ 图像模板已清空')
  
  // 销毁 Umi-OCR 服务
  destroyUmiOCRService()
  log.info('[直播叫醒] ✓ Umi-OCR 服务已销毁')
  
  // 重置处理标志
  isProcessing = false
  log.info('[直播叫醒] ✓ 处理标志已重置')

  // 清空监控窗口引用
  monitoringWindow = null
  log.info('[直播叫醒] ✓ 监控窗口引用已清空')

  // 发送停止事件到所有窗口
  const allWindows = BrowserWindow.getAllWindows()
  log.info(`[直播叫醒] ✓ 向 ${allWindows.length} 个窗口发送停止事件`)
  for (const win of allWindows) {
    win.webContents.send(IPC_CHANNELS.liveWakeup.stoppedEvent)
  }
  
  log.info('[直播叫醒] ✅ 监控已完全停止')
}

/**
 * 更新配置
 */
function updateConfig(config: Partial<LiveWakeupConfig>) {
  if (currentConfig) {
    currentConfig = { ...currentConfig, ...config }
    log.info('[直播叫醒] 配置已更新:', JSON.stringify(currentConfig))
  }
}

/**
 * 手动截图预览
 */
async function capturePreview(
  region?: { x: number; y: number; width: number; height: number }, 
  withPreprocessing?: boolean,
  preprocessMode: 'none' | 'light' | 'standard' | 'strong' = 'light'
) {
  try {
    log.info('[直播叫醒] 手动截图预览', region ? `区域: ${region.width}×${region.height} at (${region.x},${region.y})` : '全屏')
    let imgBuffer = await screenshot()
    
    // 🔍 获取完整截图的尺寸信息
    const metadata = await sharp(imgBuffer).metadata()
    log.info('[直播叫醒] 完整截图尺寸: width=' + metadata.width + ', height=' + metadata.height)
    
    // 如果指定了区域，进行裁剪
    if (region) {
      const { x, y, width, height } = region
      log.info(`[直播叫醒] 预览截图裁剪区域: x=${x}, y=${y}, width=${width}, height=${height}`)
      log.info(`[直播叫醒] 裁剪参数验证: 右边界=${x + width}, 下边界=${y + height}, 截图宽=${metadata.width}, 截图高=${metadata.height}`)
      
      if ((x + width > (metadata.width || 0)) || (y + height > (metadata.height || 0))) {
        log.error('[直播叫醒] ❌ 裁剪区域超出截图范围！')
      }
      
      try {
        // 裁剪图片
        const croppedBuffer = await sharp(imgBuffer)
          .extract({
            left: Math.round(x),
            top: Math.round(y),
            width: Math.round(width),
            height: Math.round(height),
          })
          .png()
          .toBuffer()
        
        log.info('[直播叫醒] 预览截图区域裁剪成功')
        imgBuffer = croppedBuffer
      } catch (cropError) {
        log.error('[直播叫醒] 预览截图裁剪失败，使用完整截图:', cropError)
        // 裁剪失败时，重新获取完整截图
        imgBuffer = await screenshot()
      }
    }
    
    let screenshotBase64 = `data:image/png;base64,${imgBuffer.toString('base64')}`
    let processedBase64: string | undefined
    
    // 如果需要预处理（用于OCR测试）
    if (withPreprocessing) {
      log.info(`[直播叫醒] 应用预处理模式: ${preprocessMode}`)
      const processedBuffer = await preprocessImageForOCR(imgBuffer, preprocessMode)
      processedBase64 = `data:image/png;base64,${processedBuffer.toString('base64')}`
    }
    
    return {
      success: true,
      screenshot: screenshotBase64,
      processedScreenshot: processedBase64, // 预处理后的图像（如果有）
    }
  } catch (error) {
    log.error('[直播叫醒] 手动截图失败:', error)
    return {
      success: false,
      error: error instanceof Error ? error.message : '截图失败',
    }
  }
}

/**
 * 播放音频文件
 */
async function playAudioFile(
  filePath: string, 
  volume: number = 100, 
  senderWebContents?: Electron.WebContents
): Promise<{ success: boolean; error?: string }> {
  try {
    log.info(`[音频播放] 开始播放音频文件: ${filePath}`)

    // 检查文件是否存在
    if (!fs.existsSync(filePath)) {
      return {
        success: false,
        error: '音频文件不存在',
      }
    }

    // 读取音频文件
    const audioBuffer = fs.readFileSync(filePath)
    if (!audioBuffer || audioBuffer.length === 0) {
      return {
        success: false,
        error: '音频文件为空或读取失败',
      }
    }

    // 转换为base64
    const base64Audio = audioBuffer.toString('base64')

    // 如果指定了调用者窗口，只发送给调用者
    // 否则发送给主窗口（兼容旧代码）
    if (senderWebContents && !senderWebContents.isDestroyed()) {
      senderWebContents.send('tts:play-audio', base64Audio, volume)
      log.info(`[音频播放] 音频文件播放请求已发送到调用者窗口，音量: ${volume}%`)
    } else {
      // 回退方案：发送给主窗口
      const mainWindow = BrowserWindow.getAllWindows()[0]
      if (!mainWindow) {
        return {
          success: false,
          error: '找不到任何窗口',
        }
      }
      mainWindow.webContents.send('tts:play-audio', base64Audio, volume)
      log.info(`[音频播放] 音频文件播放请求已发送到主窗口，音量: ${volume}%`)
    }
    
    // 等待播放完成
    return new Promise((resolve) => {
      const onPlayComplete = () => {
        log.info('[音频播放] 收到播放完成事件')
        cleanup()
        resolve({ success: true })
      }
      
      const onPlayError = (_event: any, error: string) => {
        log.error('[音频播放] 播放失败:', error)
        cleanup()
        resolve({ success: false, error })
      }
      
      const cleanup = () => {
        ipcMain.removeListener('tts:play-complete', onPlayComplete)
        ipcMain.removeListener('tts:play-error', onPlayError)
      }
      
      // 注册监听器
      ipcMain.once('tts:play-complete', onPlayComplete)
      ipcMain.once('tts:play-error', onPlayError)
      
      // 设置超时（30秒）
      setTimeout(() => {
        log.warn('[音频播放] 播放超时，自动结束')
        cleanup()
        resolve({ success: true })
      }, 30000)
    })
  } catch (error) {
    log.error(`[音频播放] 播放失败:`, error)
    return {
      success: false,
      error: error instanceof Error ? error.message : '播放失败',
    }
  }
}

/**
 * 初始化阿里云语音服务（从配置文件）
 */
async function initializeAliCloudVoiceFromConfig(): Promise<VoiceCallResult> {
  try {
    log.info('[阿里云语音] 从配置文件初始化语音服务')
    
    const result = initAliCloudVoiceServiceFromConfig()
    if (!result.success) {
      return {
        success: false,
        error: result.error
      }
    }

    const service = result.service!
    
    // 测试连接
    const testResult = await service.testConnection()
    if (testResult.success) {
      log.info('[阿里云语音] 服务初始化并测试成功')
      return {
        success: true,
        message: '阿里云语音服务初始化成功（使用配置文件）'
      }
    } else {
      log.error('[阿里云语音] 连接测试失败:', testResult.error)
      return testResult
    }
  } catch (error: any) {
    log.error('[阿里云语音] 初始化失败:', error)
    return {
      success: false,
      error: error.message || '初始化失败'
    }
  }
}

/**
 * 初始化阿里云语音服务（传统方式，保持向后兼容）
 */
async function initializeAliCloudVoice(config: AliCloudVoiceConfigLegacy): Promise<VoiceCallResult> {
  try {
    log.info('[阿里云语音] 开始初始化语音服务（传统方式）')
    const service = initAliCloudVoiceService(config)
    
    // 测试连接
    const testResult = await service.testConnection()
    if (testResult.success) {
      log.info('[阿里云语音] 服务初始化并测试成功')
      return {
        success: true,
        message: '阿里云语音服务初始化成功'
      }
    } else {
      log.error('[阿里云语音] 连接测试失败:', testResult.error)
      return testResult
    }
  } catch (error: any) {
    log.error('[阿里云语音] 初始化失败:', error)
    return {
      success: false,
      error: error.message || '初始化失败'
    }
  }
}

/**
 * 发送语音验证码测试
 */
async function testPhoneCall(params: { phoneNumber: string }): Promise<VoiceCallResult> {
  try {
    log.info(`[阿里云语音] 开始测试电话呼叫: ${params.phoneNumber}`)
    
    const service = getAliCloudVoiceService()
    if (!service) {
      return {
        success: false,
        error: '阿里云语音服务未初始化，请先配置AccessKey'
      }
    }

    // 构建语音验证码内容（使用配置模板）
    const ttsCode = service.getTestTemplate()
    const callParams: VoiceCallParams = {
      phoneNumber: params.phoneNumber,
      ttsCode: ttsCode,
      playTimes: 1
    }

    const result = await service.sendVoiceCaptcha(callParams)
    
    if (result.success) {
      log.info(`[阿里云语音] 语音验证码发送成功，CallId: ${result.callId}`)
    } else {
      log.error(`[阿里云语音] 语音验证码发送失败: ${result.error}`)
    }
    
    return result
  } catch (error: any) {
    log.error('[阿里云语音] 测试电话呼叫异常:', error)
    return {
      success: false,
      error: error.message || '测试呼叫失败'
    }
  }
}

/**
 * 发送实际的语音叫醒电话
 */
async function sendWakeupCall(params: { phoneNumber: string; message?: string }): Promise<VoiceCallResult> {
  try {
    log.info(`[阿里云语音] 发送叫醒电话: ${params.phoneNumber}`)
    
    const service = getAliCloudVoiceService()
    if (!service) {
      return {
        success: false,
        error: '阿里云语音服务未初始化，请先配置AccessKey'
      }
    }

    // 构建叫醒消息（使用配置模板或传入的消息）
    const wakeupMessage = params.message || service.getWakeupTemplate()
    const ttsCode = wakeupMessage

    const callParams: VoiceCallParams = {
      phoneNumber: params.phoneNumber,
      ttsCode: ttsCode,
      playTimes: 3 // 叫醒电话播放3次
    }

    const result = await service.sendVoiceCaptcha(callParams)
    
    if (result.success) {
      log.info(`[阿里云语音] 叫醒电话发送成功，CallId: ${result.callId}`)
    } else {
      log.error(`[阿里云语音] 叫醒电话发送失败: ${result.error}`)
    }
    
    return result
  } catch (error: any) {
    log.error('[阿里云语音] 发送叫醒电话异常:', error)
    return {
      success: false,
      error: error.message || '发送叫醒电话失败'
    }
  }
}

/**
 * 设置IPC处理器
 */
export function setupLiveWakeupIpcHandlers() {
  // 启动监控
  ipcMain.handle(IPC_CHANNELS.liveWakeup.start, async (event, config: LiveWakeupConfig) => {
    return await startMonitoring(config, event.sender)
  })

  // 停止监控
  ipcMain.handle(IPC_CHANNELS.liveWakeup.stop, () => {
    stopMonitoring()
  })

  // 更新配置
  ipcMain.handle(IPC_CHANNELS.liveWakeup.updateConfig, (_event, config: Partial<LiveWakeupConfig>) => {
    updateConfig(config)
  })

  // 手动截图预览
  ipcMain.handle(IPC_CHANNELS.liveWakeup.capturePreview, async (
    _event, 
    region?: { x: number; y: number; width: number; height: number }, 
    withPreprocessing?: boolean,
    preprocessMode?: 'none' | 'light' | 'standard' | 'strong'
  ) => {
    return await capturePreview(region, withPreprocessing, preprocessMode)
  })

  // 播放音频文件
  ipcMain.handle(IPC_CHANNELS.liveWakeup.playAudioFile, async (event, params: { filePath: string; volume?: number }) => {
    return await playAudioFile(params.filePath, params.volume, event.sender)
  })

  // 初始化阿里云语音服务（从配置文件）
  ipcMain.handle('liveWakeup:initAliCloudVoiceFromConfig', async (_event) => {
    return await initializeAliCloudVoiceFromConfig()
  })

  // 初始化阿里云语音服务（传统方式，保持向后兼容）
  ipcMain.handle('liveWakeup:initAliCloudVoice', async (_event, config: AliCloudVoiceConfigLegacy) => {
    return await initializeAliCloudVoice(config)
  })

  // 获取阿里云语音服务配置状态
  ipcMain.handle('liveWakeup:getConfigStatus', async (_event) => {
    try {
      const service = getAliCloudVoiceService()
      if (service) {
        return {
          success: true,
          status: service.getConfigStatus(),
          configPath: aliCloudConfigManager.getConfigPath()
        }
      } else {
        // 尝试从配置文件检查
        const configValid = aliCloudConfigManager.isConfigValid()
        return {
          success: true,
          status: {
            isConfigured: configValid,
            source: configValid ? 'file' : 'none'
          },
          configPath: aliCloudConfigManager.getConfigPath()
        }
      }
    } catch (error: any) {
      return {
        success: false,
        error: error.message || '获取配置状态失败'
      }
    }
  })

  // 获取配置文件路径
  ipcMain.handle('liveWakeup:getConfigPath', async (_event) => {
    try {
      return {
        success: true,
        path: aliCloudConfigManager.getConfigPath()
      }
    } catch (error: any) {
      return {
        success: false,
        error: error.message || '获取配置路径失败'
      }
    }
  })

  // 重新加载配置文件
  ipcMain.handle('liveWakeup:reloadConfig', async (_event) => {
    try {
      const service = getAliCloudVoiceService()
      if (service) {
        const result = await service.reloadConfigFromFile()
        return result
      } else {
        const result = aliCloudConfigManager.reloadConfig()
        return result
      }
    } catch (error: any) {
      return {
        success: false,
        error: error.message || '重新加载配置失败'
      }
    }
  })

  // 测试电话呼叫
  ipcMain.handle('liveWakeup:testPhoneCall', async (_event, params: { phoneNumber: string }) => {
    return await testPhoneCall(params)
  })

  // 发送叫醒电话
  ipcMain.handle('liveWakeup:sendWakeupCall', async (_event, params: { phoneNumber: string; message?: string }) => {
    return await sendWakeupCall(params)
  })

  // 加载模板图片（返回dataUrl供前端预览）
  ipcMain.handle('liveWakeup:loadTemplateImage', async (_event, filePath: string) => {
    try {
      log.info(`[模板图片] 加载图片: ${filePath}`)
      
      if (!fs.existsSync(filePath)) {
        return {
          success: false,
          error: '文件不存在',
        }
      }

      // 读取图片并转换为base64
      const imageBuffer = fs.readFileSync(filePath)
      const dataUrl = `data:image/png;base64,${imageBuffer.toString('base64')}`
      
      log.info(`[模板图片] 图片加载成功`)
      return {
        success: true,
        dataUrl,
      }
    } catch (error) {
      log.error(`[模板图片] 加载失败:`, error)
      return {
        success: false,
        error: error instanceof Error ? error.message : '加载失败',
      }
    }
  })

  // 测试 Umi-OCR 识别
  ipcMain.handle('liveWakeup:testUmiOCR', async (_event, params: { 
    imageBase64: string
    apiUrl: string
    language: string
  }) => {
    try {
      log.info('[Umi-OCR测试] 开始测试识别')
      
      // 临时创建 Umi-OCR 服务实例进行测试
      const testService = initUmiOCRService({
        apiUrl: params.apiUrl,
        language: params.language,
        timeout: 10000,
      })
      
      // 测试连接
      const connectionTest = await testService.testConnection()
      if (!connectionTest.success) {
        return {
          success: false,
          error: `连接失败: ${connectionTest.error}`,
        }
      }
      
      // 执行识别
      const startTime = Date.now()
      const result = await testService.recognize(params.imageBase64)
      const elapsed = Date.now() - startTime
      
      if (result.success) {
        log.info(`[Umi-OCR测试] 识别成功，耗时: ${elapsed}ms`)
        return {
          success: true,
          text: result.text || '',
          elapsed: elapsed,
          details: result.details,
        }
      } else {
        log.error(`[Umi-OCR测试] 识别失败: ${result.error}`)
        return {
          success: false,
          error: result.error,
        }
      }
    } catch (error) {
      log.error('[Umi-OCR测试] 测试失败:', error)
      return {
        success: false,
        error: error instanceof Error ? error.message : '测试失败',
      }
    }
  })

  log.info('[直播叫醒] IPC处理器已注册')
}

// 应用退出时清理
process.on('exit', () => {
  if (monitorInterval) {
    clearInterval(monitorInterval)
  }
  destroyAliCloudVoiceService()
  destroyUmiOCRService()
})

